home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Sample Code / Snippets / Printing / PDlog Expand (TN PR09) / PDlog Expand.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-24  |  17.0 KB  |  612 lines  |  [TEXT/KAHL]
  1. /* PDlog Expand.c    Derived    from TN #95.
  2.  
  3. Dave Hersey, Apple Developer Technical Support.
  4.  
  5.     10/9/91…    v1.0
  6.     2/25/92…    v1.0.1 --> fixed lack of print handle tossing and added something to print.    <dmh>
  7.     9/29/93…    v1.0.2 --> fixed bug in Append_DITL (also in TN #95) which appends 2 extra bytes. <dmh>
  8.     6/20/95…    v1.0.3 --> updated for Universal Headers and MWC-PPC    <njvt>
  9.     11/16/95    v1.0.4 --> updated to use CallPItemProc() and PItemUPP. Make it fully ANSI.
  10.                         Explicitly include needed headers, so back-port to MPW is easier. <davep>
  11.     6/10/96        v1.1   --> Use the OS's AppendDITL if it's there. Add balloon help. <davep>
  12.     8/21/96        v1.1.1 --> Added the list for a sample     (mxm)
  13.     9/3/96        v1.1.2 --> Change list handling to match recommendations of LW8 engineering. <davep>
  14.  
  15.     NOTE: Apple reserves the top half of the screen (where the current DITL
  16.     items are located). Applications may use the bottom half of the screen to
  17.     add items, but should not change any items in the top half of the screen.
  18.     An application should expand the print dialogs only as much as is
  19.     absolutely necessary.
  20.  
  21.     A global search and replace of 'Job' with 'Stl' will produce code that
  22.     modifies the style dialog.
  23.     
  24.  
  25. */
  26.  
  27. #include <Printing.h>
  28. #include <Dialogs.h>
  29. #include <Gestalt.h>
  30. #include <MixedMode.h>
  31. #include <SegLoad.h>
  32. #include <Resources.h>
  33. #include <ToolUtils.h>
  34. #include <Fonts.h>
  35. #include <Lists.h>
  36.  
  37. static TPPrDlg PrtJobDialog;    /* pointer to job dialog */
  38.  
  39. /* 
  40.  
  41. This points to the following structure:
  42.  
  43. struct TPrDlg {
  44.     DialogRecord                    Dlg;                        // The Dialog window
  45.     ModalFilterUPP                    pFltrProc;                    // The Filter Proc.
  46.     PItemUPP                        pItemProc;                    // The Item evaluating proc.
  47.     THPrint                            hPrintUsr;                    // The user's print record.
  48.     Boolean                            fDoIt;
  49.     Boolean                            fDone;
  50.     long                            lUser1;                        // Four longs for apps to hang global data.
  51.     long                            lUser2;                        // Plus more stuff needed by the particular
  52.     long                            lUser3;                        // printing dialog.
  53.     long                            lUser4;
  54. };
  55. typedef struct TPrDlg TPrDlg;
  56. typedef TPrDlg *TPPrDlg;
  57. typedef TPPrDlg TPPrDlgRef;
  58.  
  59. */
  60.  
  61. /* Declare ‘pascal’ functions and procedures */
  62.  
  63. extern short    Append_DITL(TPPrDlg, short);        /* Our AppendDITL function.            */
  64. extern pascal    TPPrDlg MyJobDlgInit(THPrint);        /* Our extention to PrJobInit.        */
  65. extern pascal    void MyJobItems(TPPrDlg, short);    /* Our modal item handler.            */
  66. extern OSErr    Print(void);
  67. pascal void MyListDraw(WindowPtr theWindow, short itemNo); //mxm
  68.  
  69. #define MyDITL 256    /* resource ID of my DITL to be spliced onto job dialog */
  70. #define kPanePopUp (6)            /* mxm */
  71.  
  72. ListHandle     gList = nil;                 /* mxm */
  73. UserItemUPP    myDrawListUPP = nil;         /* mxm */
  74.  
  75. THPrint hPrintRec;    /* handle to print record */
  76. long prFirstItem;    /* save our first item here */
  77. PItemUPP prPItemProc;    /* we need to store the old itemProc here */
  78.  
  79. /*-----------------------------------------------------------------------*/
  80.     WindowPtr    MyWindow;
  81.     OSErr    err;
  82.     Str255    myStr;
  83.  
  84. #if PRAGMA_ALIGN_SUPPORTED
  85. #pragma options align=mac68k
  86. #endif
  87.  
  88. typedef struct dialog_item_struct {
  89.     Handle    handle;    /* handle or procedure pointer for this item */
  90.     Rect    bounds;    /* display rectangle for this item */
  91.     char    type;    /* item type - 1 */
  92.     char    data[1];    /* length byte of data */
  93. } DialogItem, *DialogItemPtr, **DialogItemHandle;
  94.  
  95. typedef struct append_item_list_struct {
  96.     short    max_index; /* number of items - 1 */
  97.     DialogItem    items[1]; /* first item in the array */
  98. } ItemList, *ItemListPtr, **ItemListHandle;
  99.  
  100. typedef union signed_byte_union {
  101.     short    integer;
  102.     char    bytes[2];
  103. } ByteAccess;
  104.  
  105.  
  106. static Boolean append_exits(void);
  107. static Boolean append_exits(void)
  108. {
  109.     long    response;
  110.  
  111.     if (Gestalt(gestaltDITLExtAttr,&response) == noErr) {
  112.         return !!(response & (1 << gestaltDITLExtPresent));
  113.     } else {
  114.         return false;    /* simple-minded, but hey, so am I. -DaveP */
  115.     }
  116. }
  117.  
  118.  
  119. /*    This routine appends all of the items of a specified DITL    */
  120. /*    onto the end of a specified DLOG — We don’t even need to know the format    */
  121. /*    of the DLOG    */
  122.  
  123. /*    this will be done in 3 steps:    */
  124. /*    1. append the items of the specified DITL onto the existing DLOG    */
  125. /*    2. expand the original dialog window as required    */
  126. /*    3. return the adjusted number of the first new user item    */
  127.  
  128. short Append_DITL(TPPrDlg dialog, short item_list_ID)
  129. {
  130.     ItemListHandle     append_item_list;    /* handle to DITL being appended */
  131.     ItemListHandle    dlg_item_list;    /* handle to DLOG's item list */
  132.     short            first_item;
  133.  
  134.     dlg_item_list = (ItemListHandle)((DialogPeek)dialog)->items;
  135.     first_item = (**dlg_item_list).max_index + 2;
  136.  
  137.     append_item_list = (ItemListHandle)GetResource('DITL', item_list_ID);
  138.     if ( append_item_list == NULL ) {
  139.         DebugStr("\pError loading DITL resource");
  140.         return first_item;
  141.     }
  142.  
  143.     if (append_exits()) {
  144.         AppendDITL((DialogPtr)dialog, (Handle) append_item_list, appendDITLBottom);
  145.         return first_item;
  146.     } else {
  147.         Point        offset;
  148.         Rect        max_rect;
  149.         DialogItemPtr     item;    /* pointer to item being appended */
  150.         short        new_items, data_size, i;
  151.         ByteAccess    usb;
  152.         OSErr        err;
  153.  
  154.     /*
  155.         Using the original DLOG
  156.      
  157.         1. Remember the original window Size.
  158.         2. Set the offset Point to be the bottom of the original window.
  159.         3. Subtract 5 pixels from bottom and right, to be added
  160.         back later after we have possibly expanded window.
  161.         4. Get working Handle to original item list.
  162.         5. Calculate our first item number to be returned to caller.
  163.         6. Get locked Handle to DITL to be appended.
  164.         7. Calculate count of new items.
  165.     */
  166.      
  167.         if (dialog == NULL) ExitToShell();
  168.      
  169.         max_rect = ((DialogPeek)dialog)->window.port.portRect;
  170.         offset.v = max_rect.bottom;
  171.         offset.h = 0;
  172.         max_rect.bottom -= 5;
  173.         max_rect.right -= 5;
  174.      
  175.     
  176.         HLock((Handle)append_item_list);
  177.         new_items = (**append_item_list).max_index + 1;
  178.      
  179.     /*
  180.         For each item,
  181.         1. Offset the rectangle to follow the original window.
  182.         2. Make the original window larger if necessary.
  183.         3. fill in item handle according to type.
  184.     */
  185.      
  186.         item = (**append_item_list).items;
  187.         for ( i = 0; i < new_items; i++ )
  188.         {
  189.             OffsetRect(&item->bounds, offset.h, offset.v);
  190.             UnionRect(&item->bounds, &max_rect, &max_rect);
  191.             usb.integer = 0;
  192.             usb.bytes[1] = item->data[0];
  193.      
  194.             switch ( item->type & 0x7F )
  195.             {
  196.                 case ctrlItem + btnCtrl :
  197.                 case ctrlItem + chkCtrl :
  198.                 case ctrlItem + radCtrl :
  199.                     item->handle = (Handle)NewControl((DialogPtr) dialog,
  200.                         &item->bounds, (StringPtr)item->data, true,
  201.                         0, 0, 1, item->type & 0x03, 0);
  202.                 break;
  203.      
  204.                 case ctrlItem + resCtrl :
  205.                 {
  206.                     item->handle = (Handle)GetNewControl(*(short*)(item->data + 1), (DialogPtr) dialog);
  207.                     (**(ControlHandle)item->handle).contrlRect = item->bounds;
  208.                 }
  209.                 break;
  210.     
  211.                 case statText :
  212.                 case editText :
  213.                     err = PtrToHand(item->data + 1, &item->handle, usb.integer);
  214.                 break;
  215.     
  216.                 case iconItem :
  217.                     item->handle = GetIcon(*(short*)(item->data + 1));
  218.                 break;
  219.      
  220.                 case picItem :
  221.                     item->handle = (Handle)GetPicture(*(short*)(item->data + 1));
  222.                 break;
  223.      
  224.                 default :
  225.                     item->handle = NULL;
  226.             }
  227.      
  228.             data_size = (usb.integer + 1) & 0xFFFE;
  229.             item = (DialogItemPtr)((char*)item + data_size + sizeof(DialogItem));
  230.         }
  231.      
  232.      /* We need to subtract the short below because otherwise the size of the DITL count
  233.      ** gets factored in twice, and the resulting DTIL has two bytes of garbage appended
  234.      ** to it. This is a problem with the original TN#95 code as well.
  235.      */
  236.      
  237.         err = PtrAndHand((**append_item_list).items,
  238.                         (Handle)dlg_item_list,
  239.                         GetHandleSize((Handle) append_item_list)
  240.                         - sizeof(short));
  241.     
  242.         (**dlg_item_list).max_index += new_items;
  243.         HUnlock((Handle) append_item_list);
  244.         ReleaseResource((Handle) append_item_list);
  245.      
  246.         max_rect.bottom += 5;
  247.         max_rect.right += 5;
  248.         SizeWindow((WindowPtr) dialog, max_rect.right, max_rect.bottom, true);
  249.      
  250.         return first_item;
  251.     }
  252. }
  253.  
  254.  
  255. /*------------------------------------------------------------------------*/
  256.  
  257. OSErr Print(void)
  258. {
  259.     TPPrPort    pPrPort;
  260.     Rect        aRect;
  261.     TPrStatus    theStatus;
  262.  
  263.  
  264.     /* call PrJobInit to get pointer to the invisible job dialog */
  265.     hPrintRec = (THPrint)(NewHandle(sizeof(TPrint)));
  266.     PrintDefault(hPrintRec);
  267.     PrValidate(hPrintRec);
  268.     if (PrError() != noErr)
  269.         return PrError();
  270.  
  271.     PrtJobDialog = PrJobInit(hPrintRec);
  272.  
  273.     if (PrError() != noErr)
  274.         return PrError();
  275.  
  276.     if (!PrDlgMain(hPrintRec, NewPDlgInitProc(MyJobDlgInit))) /* this line does all the stuff */
  277.         return iPrAbort;
  278.  
  279.     if (myDrawListUPP) {  /* get rid of our user item draw proc mxm */
  280.         DisposeRoutineDescriptor(myDrawListUPP);
  281.     } 
  282.     if (PrError() != noErr)
  283.         return PrError();
  284.  
  285.     pPrPort = PrOpenDoc(hPrintRec, NULL, NULL);
  286.     PrOpenPage(pPrPort, NULL);
  287.  
  288.     aRect = (*hPrintRec)->prInfo.rPage;
  289.     InsetRect(&aRect, 20, 20);
  290.     PenSize(4, 4);
  291.     FrameRect(&aRect);
  292.  
  293.     PrClosePage(pPrPort);
  294.     PrCloseDoc(pPrPort);
  295.  
  296.     if (!PrError() && (*hPrintRec)->prJob.bJDocLoop == bSpoolLoop)
  297.         PrPicFile(hPrintRec, NULL, NULL, NULL, &theStatus);
  298.  
  299.  
  300. /* that's all for now */
  301.  
  302.     if (hPrintRec) DisposeHandle((Handle) hPrintRec);
  303.  
  304.     return(noErr);
  305. } /* Print */
  306.  
  307.  
  308. //-----------------------------------------------------------------------------
  309. pascal void MyListDraw(WindowPtr theWindow, short itemNo)
  310. //-----------------------------------------------------------------------------
  311. {
  312. #pragma unused (theWindow,itemNo)
  313.  
  314.     short    itemType;
  315.     Handle    itemH;
  316.     Rect    itemBox,r;    
  317.     Point     pt;
  318.     ControlRef cr;
  319.     RgnHandle clip = NewRgn();
  320.     
  321.     if (itemNo == kPanePopUp) {
  322.         cr = gList[0]->vScroll;
  323.         HideControl(cr);
  324.         return;
  325.     }
  326.     
  327.     GetDialogItem((DialogPtr) PrtJobDialog,itemNo,&itemType,&itemH,&itemBox);
  328.     r = theWindow->portRect;
  329.     pt.h = itemBox.left;
  330.     pt.v = itemBox.top;
  331.     cr = gList[0]->vScroll;
  332.     MoveControl(cr,itemBox.right-15,itemBox.top-1);
  333.     ShowControl(cr);
  334.     if (PtInRect(pt,&r)) {
  335.         
  336.         gList[0]->rView = itemBox;
  337.         gList[0]->rView.right -=15;  //inset for scroll bar
  338.  
  339.         ShowControl(cr);
  340.         LSetDrawingMode(true,gList);
  341.         if (clip) {
  342.             RectRgn(clip,&itemBox);
  343.             LUpdate(clip,gList);
  344.         
  345.             InsetRect(&itemBox,-1,-1);
  346.             FrameRect(&itemBox);
  347.             DisposeRgn(clip);
  348.         }
  349.     
  350.     } 
  351. }
  352.  
  353. /*------------------------------------------------------------------------*/
  354.  
  355. pascal TPPrDlg MyJobDlgInit(THPrint hPrint)
  356. /*
  357.     this routine appends items to the standard job dialog and sets up the
  358.     user fields of the printing dialog record TPRDlg
  359.  
  360.     This routine will be called by PrDlgMain
  361. */
  362.  
  363. {
  364. #pragma unused(hPrint)
  365.  
  366.     short    firstItem;    /* first new item number */
  367.  
  368.     short    itemType, item;
  369.     Handle    itemH;
  370.     Rect    itemBox;
  371.  
  372.     firstItem = Append_DITL(PrtJobDialog, MyDITL); /* call routine to do this */
  373.  
  374.     prFirstItem = firstItem; /* save this so MyJobItems can find it */
  375.  
  376.     /* now we'll set up our DITL items -- The radio buttons */
  377.  
  378.     for (item = 5; item <= 7; item++)
  379.     {
  380.         GetDialogItem((DialogPtr) PrtJobDialog,firstItem + item -1,&itemType,&itemH,&itemBox);
  381.         SetCtlValue((ControlHandle) itemH, (item == 5));
  382.     }
  383.  
  384.     /* now we'll set up the second of our DITL items -- The checkbox */
  385.  
  386.     GetDialogItem((DialogPtr) PrtJobDialog,firstItem +2,&itemType,&itemH,&itemBox);
  387.     SetCtlValue((ControlHandle) itemH,1);
  388.  
  389.     
  390.     // here is the list stuff (mxm)    
  391.     {
  392.         Rect bounds ;
  393.         Point theCell = {16,200};
  394.         
  395.         
  396.         GetDialogItem((DialogPtr) PrtJobDialog,firstItem +8,&itemType,&itemH,&itemBox);
  397.  
  398.         SetRect(&bounds,0,0,1,0);
  399.         itemBox.right -=15;
  400.          
  401.         gList  = LNew(&itemBox,&bounds,theCell,0,(GrafPtr)PrtJobDialog,false,false,false,true);
  402.         if (gList) {    // this is how you need to do the scroll-bar so it'll
  403.                         // move off correctly with LaserWriter 8.4 and later
  404.                         //
  405.                         // The theory is that we have another user item which
  406.                         // has the handle for the control item for the scrollbar
  407.                         // for the list. This way, the scroll bar gets redrawn
  408.                         // in the right order, so it realises it's off the panel
  409.                         // when it is. If you don't have this code, the scroller
  410.                         // gets drawn, then the list gets moved, so you get a
  411.                         // phantom scroller in the dialog. -DaveP 9/3/96
  412.             short    scrollType;
  413.             Handle    scrollHandle;
  414.             Rect    scrollRect;
  415.             GetDialogItem((DialogPtr)PrtJobDialog,firstItem + 9, &scrollType,
  416.                 &scrollHandle, &scrollRect);
  417.             SetDialogItem((DialogPtr)PrtJobDialog,firstItem + 9, ctrlItem,
  418.                 (Handle) (**gList).vScroll, &scrollRect);
  419.         }
  420.         LAddRow(9,0,gList);
  421.         SetPt(&theCell,0,0);
  422.         // Lets add some data
  423.         LSetCell("Testing 1",9,theCell,gList);
  424.         theCell.v ++;
  425.         LSetCell("Testing 2",9,theCell,gList);
  426.         theCell.v ++;
  427.         LSetCell("Testing 3",9,theCell,gList);
  428.         theCell.v ++;
  429.         LSetCell("Testing 4",9,theCell,gList);
  430.         theCell.v ++;
  431.         LSetCell("Testing 5",9,theCell,gList);
  432.         theCell.v ++;
  433.         LSetCell("Testing 6",9,theCell,gList);
  434.         theCell.v ++;
  435.         LSetCell("Testing 7",9,theCell,gList);
  436.         theCell.v ++;
  437.         LSetCell("Testing 8",9,theCell,gList);
  438.         theCell.v ++;
  439.         LSetCell("Testing 9",9,theCell,gList);    
  440.         
  441.         LActivate(true,gList);
  442.         myDrawListUPP =  NewUserItemProc(MyListDraw);
  443.                                                                                     
  444.         SetDialogItem((DialogPtr) PrtJobDialog,firstItem + 8,itemType,(Handle)myDrawListUPP,&itemBox);
  445.                                                                         
  446.     }
  447.     
  448. /*
  449.     Now comes the part where we patch in our item handler. We have to save
  450.     the old item handler address, so we can call it if one of the standard
  451.     items is hit, and put our item handler's address in pItemProc field of
  452.     the TPrDlg struct
  453. */
  454.  
  455.     prPItemProc = PrtJobDialog->pItemProc;
  456.  
  457. /* Now we'll tell the modal item handler where our routine is */
  458.     PrtJobDialog->pItemProc = NewPItemProc(MyJobItems) ;
  459.  
  460.  
  461. /* PrDlgMain expects a pointer to the modified dialog to be returned...*/
  462.     return PrtJobDialog;
  463.  
  464. } /*myJobDlgInit*/
  465.  
  466. /*-----------------------------------------------------------------------*/
  467.  
  468.  static pascal Boolean    testFilter(DialogPtr theDialog, EventRecord *theEvent, short *itemHit)
  469. {
  470. #pragma unused(theDialog)
  471. #pragma unused(theEvent)
  472. #pragma unused(itemHit)
  473. //    DebugStr("\pMy filter proc got called");    // This gets called a lot if you uncomment it
  474.     return false;
  475. }
  476.  
  477. static pascal void testDialogUserItem(WindowPtr theWindow, short itemNo);
  478. static pascal void testDialogUserItem(WindowPtr theWindow, short itemNo)
  479. {
  480.     if (itemNo != 4) return;
  481.     else {
  482.         short    oldFont = ((GrafPtr)theWindow)->txFont;
  483.         short    oldSize = ((GrafPtr)theWindow)->txSize;
  484.         short    itemType;
  485.         Handle    h;
  486.         Rect    r;
  487.  
  488.         SetPort(theWindow);
  489.         TextFont(GetAppFont());
  490.         TextSize(9);
  491.         GetDialogItem((DialogPtr)theWindow,4,&itemType,&h,&r);
  492.         MoveTo(r.left,r.bottom);
  493.         DrawString("\pThe Pooh-snif network.");
  494.         TextFont(oldFont);
  495.         TextSize(oldSize);
  496.     }
  497. }
  498.  
  499. static void TestDialog(void);
  500. static void TestDialog(void)
  501. {
  502.     DialogPtr    theDialog = GetNewDialog(257,nil,(WindowPtr)-1L);
  503.     short    itemHit = 0;
  504.     ModalFilterUPP    mySubDialogFilterProc = nil;    // NewModalFilterProc(testFilter); // for testing
  505.     UserItemUPP        mySubDialogUserProc = NewUserItemProc(testDialogUserItem);
  506.  
  507.     {        // set up the user item to draw the outline around the ok button
  508.         short    t;
  509.         Handle    h;
  510.         Rect    r;
  511.         
  512.         GetDialogItem(theDialog,4,&t,&h,&r);
  513.         SetDialogItem(theDialog,4,t,(Handle)mySubDialogUserProc,&r);
  514.     }
  515.  
  516.     SetDialogDefaultItem(theDialog,1);
  517.     while((itemHit != 1) && (itemHit != 2)) {    // a WAY bad way of seeing if we're done, but I'm in a hurry
  518.         ModalDialog(mySubDialogFilterProc, &itemHit);
  519.     }
  520.     DisposeDialog(theDialog);
  521.     if (mySubDialogFilterProc != nil)
  522.         DisposeRoutineDescriptor(mySubDialogFilterProc);
  523.     if (mySubDialogUserProc != nil)
  524.         DisposeRoutineDescriptor(mySubDialogUserProc);
  525. }
  526.  
  527. /* here's the analogue to the SF dialog hook */
  528.  
  529. pascal void MyJobItems( TPPrDlg theDialog, short itemNo )
  530. { /* MyJobItems */
  531.     short    myItem;
  532.     short    firstItem, item, itemType, theValue;
  533.     Handle    itemH;
  534.     Rect    itemBox;
  535.  
  536.     firstItem = prFirstItem;    /* remember, we saved this in myJobDlgInit */
  537. //    DebugStr("\p Looking at the item...");
  538.     myItem = itemNo-firstItem+1;    /* "localize" current item No */
  539.     if (myItem > 0)    /* if localized item > 0, it's one of ours */
  540.     {
  541.         /* find out which of our items was hit */
  542.  
  543.         switch (myItem)
  544.         {
  545.             case 1:            /*    Static text.    */
  546.                 break;
  547.             case 2:            /*    Edit text.        */
  548.                 break;
  549.             case 3:            /*    Check box.        */
  550.                     GetDialogItem((DialogPtr) theDialog,firstItem +2,&itemType,&itemH,&itemBox);
  551.                      theValue = GetCtlValue((ControlHandle) itemH);
  552.                      SetCtlValue((ControlHandle) itemH, theValue != 1);
  553.                 break;
  554.             case 4:            /*    Push button.    */
  555.                 TestDialog();
  556.                 break;
  557.             case 5:            /*    Radio buttons    */
  558.             case 6:
  559.             case 7:
  560.                 for (item = 5; item <= 7; item++) {
  561.                     GetDialogItem((DialogPtr) theDialog,firstItem +item -1,&itemType,&itemH,&itemBox);
  562.                      SetCtlValue((ControlHandle) itemH, item == myItem);
  563.                 }
  564.                 break;
  565.             case 8:            /*    Edit text.        */
  566.             case 9:            /*    Our List.        */ 
  567.                 {    
  568.                     Point pt;
  569.                     GetMouse(&pt);
  570.                     LClick(pt,0,gList);
  571.                 }
  572.                 break;
  573.             case 10:        /* our list's scroll bar. We don't need to do anything, but we need
  574.                             * to have some code here so we don't hit the default case */
  575.                 break;
  576.             default: Debugger(); /* OH OH */
  577.         } /* switch */
  578.     } /* if (myItem > 0) */
  579.     else /* chain to standard item handler, whose address is saved in prPItemProc */
  580.     {
  581.         CallPItemProc(prPItemProc,(DialogPtr)theDialog, itemNo);
  582.         
  583.         if (theDialog->fDone) {
  584.             // we're going away, need to clean up our scroll bar and list
  585.             if (gList) {
  586.                 (**gList).vScroll = 0L;
  587.                 LDispose(gList);
  588.             }
  589.         }
  590.     }
  591. } /* MyJobItems */
  592.  
  593.  
  594. void main(void)
  595. {
  596.     Rect    myWRect;
  597.  
  598.     InitGraf(&qd.thePort);
  599.     InitFonts();
  600.     InitWindows();
  601.     InitMenus();
  602.     InitDialogs((long)nil);
  603.     InitCursor();
  604.     SetRect(&myWRect,50,260,350,340);
  605.  
  606.     /* call the routine that does printing */
  607.     PrOpen();
  608.     err = Print();
  609.  
  610.     PrClose();
  611. } /* main */
  612.